Within the field of computing, many scenarios involve the inspection of a type system in one of several domains that may differ in certain properties. These domains may provide different implementations for a common type interface. For example, a compiler may create and inspect static types at compile time. A debugger may inspect types that exist in a debuggee process. An IDE may inspect types constructed from user code fragments as the code is being developed. A native execution domain or simulator may create objects that are instances of the given types.
The code executed within such domains often involves the storing of type instances in a region of memory of the computer. The type instance may be of various types, such as a primitive type (e.g., an integer or a string); a plurality of several type instances (e.g., an array); a composite of several type instances (e.g., a structure or a class instance); or a reference to a memory location (e.g., a pointer.) The memory allocated for storing these types of type instances may also take many forms, such as a region of randomly accessible memory, a stack, a queue, and a heap.